/**
 * 数据库连接工具
 * 用于与本地数据库进行通信
 */

import config from './config.js'

// 数据库配置
const DB_CONFIG = {
    host: '115.29.225.14',
    // host: 'localhost',
    port: 3306,
    user: 'breathe-applet',
    // user: 'root',
    password: 'root',
    database: 'breathe-applet',
    charset: 'utf8mb4'
}

/**
 * 数据库操作类
 */
class DatabaseService {
    constructor() {
        this.baseUrl = config.BASE_URL
        this.token = uni.getStorageSync(config.TOKEN) || ''
    }

    /**
     * 设置请求头
     */
    getHeaders() {
        return {
            'Content-Type': 'application/json',
            'Authorization': this.token ? `Bearer ${this.token}` : ''
        }
    }

    /**
     * 通用请求方法
     * @param {string} url - 请求地址
     * @param {string} method - 请求方法
     * @param {object} data - 请求数据
     * @returns {Promise}
     */
    async request(url, method = 'GET', data = null) {
        return new Promise((resolve, reject) => {
            uni.request({
                url: `${this.baseUrl}${url}`,
                method: method,
                data: data,
                header: this.getHeaders(),
                success: (res) => {
                    if (res.statusCode === 200) {
                        resolve(res.data)
                    } else {
                        reject(new Error(`请求失败: ${res.statusCode}`))
                    }
                },
                fail: (err) => {
                    reject(new Error(`网络请求失败: ${err.errMsg}`))
                }
            })
        })
    }

    /**
     * 查询数据
     * @param {string} table - 表名
     * @param {object} conditions - 查询条件
     * @param {object} options - 查询选项（分页、排序等）
     * @returns {Promise}
     */
    async query(table, conditions = {}, options = {}) {
        const data = {
            table: table,
            conditions: conditions,
            options: options
        }
        return this.request('/api/database/query', 'POST', data)
    }

    /**
     * 插入数据
     * @param {string} table - 表名
     * @param {object} data - 要插入的数据
     * @returns {Promise}
     */
    async insert(table, data) {
        const requestData = {
            table: table,
            data: data
        }
        return this.request('/api/database/insert', 'POST', requestData)
    }

    /**
     * 更新数据
     * @param {string} table - 表名
     * @param {object} data - 要更新的数据
     * @param {object} conditions - 更新条件
     * @returns {Promise}
     */
    async update(table, data, conditions = {}) {
        const requestData = {
            table: table,
            data: data,
            conditions: conditions
        }
        return this.request('/api/database/update', 'POST', requestData)
    }

    /**
     * 删除数据
     * @param {string} table - 表名
     * @param {object} conditions - 删除条件
     * @returns {Promise}
     */
    async delete(table, conditions = {}) {
        const requestData = {
            table: table,
            conditions: conditions
        }
        return this.request('/api/database/delete', 'POST', requestData)
    }

    /**
     * 执行自定义SQL
     * @param {string} sql - SQL语句
     * @param {array} params - SQL参数
     * @returns {Promise}
     */
    async executeSQL(sql, params = []) {
        const data = {
            sql: sql,
            params: params
        }
        return this.request('/api/database/execute', 'POST', data)
    }

    /**
     * 获取数据库连接状态
     * @returns {Promise}
     */
    async getConnectionStatus() {
        return this.request('/api/database/status', 'GET')
    }

    /**
     * 测试数据库连接
     * @returns {Promise}
     */
    async testConnection() {
        try {
            const result = await this.getConnectionStatus()
            return {
                success: true,
                message: '数据库连接正常',
                data: result
            }
        } catch (error) {
            return {
                success: false,
                message: '数据库连接失败',
                error: error.message
            }
        }
    }
}

/**
 * 数据库表操作示例
 */
class TableOperations {
    constructor() {
        this.db = new DatabaseService()
    }

    /**
     * 用户相关操作
     */
    user = {
        // 获取用户列表
        getList: (conditions = {}, options = {}) => {
            return this.db.query('users', conditions, options)
        },
        // 根据ID获取用户
        getById: (id) => {
            return this.db.query('users', { id: id })
        },
        // 创建用户
        create: (userData) => {
            return this.db.insert('users', userData)
        },
        // 更新用户
        update: (id, userData) => {
            return this.db.update('users', userData, { id: id })
        },
        // 删除用户
        delete: (id) => {
            return this.db.delete('users', { id: id })
        }
    }

    /**
     * 呼吸数据相关操作
     */
    breatheData = {
        // 获取呼吸数据列表
        getList: (conditions = {}, options = {}) => {
            return this.db.query('breathe_data', conditions, options)
        },
        // 根据用户ID获取呼吸数据
        getByUserId: (userId, options = {}) => {
            return this.db.query('breathe_data', { user_id: userId }, options)
        },
        // 创建呼吸数据记录
        create: (data) => {
            return this.db.insert('breathe_data', data)
        },
        // 更新呼吸数据
        update: (id, data) => {
            return this.db.update('breathe_data', data, { id: id })
        },
        // 删除呼吸数据
        delete: (id) => {
            return this.db.delete('breathe_data', { id: id })
        }
    }

    /**
     * 报告相关操作
     */
    report = {
        // 获取报告列表
        getList: (conditions = {}, options = {}) => {
            return this.db.query('reports', conditions, options)
        },
        // 根据ID获取报告
        getById: (id) => {
            return this.db.query('reports', { id: id })
        },
        // 创建报告
        create: (reportData) => {
            return this.db.insert('reports', reportData)
        },
        // 更新报告
        update: (id, reportData) => {
            return this.db.update('reports', reportData, { id: id })
        },
        // 删除报告
        delete: (id) => {
            return this.db.delete('reports', { id: id })
        }
    }
}

// 创建实例
const databaseService = new DatabaseService()
const tableOperations = new TableOperations()

// 导出
export default {
    // 数据库配置
    config: DB_CONFIG,
    // 数据库服务实例
    service: databaseService,
    // 表操作实例
    tables: tableOperations,
    // 直接导出方法
    query: databaseService.query.bind(databaseService),
    insert: databaseService.insert.bind(databaseService),
    update: databaseService.update.bind(databaseService),
    delete: databaseService.delete.bind(databaseService),
    executeSQL: databaseService.executeSQL.bind(databaseService),
    testConnection: databaseService.testConnection.bind(databaseService)
} 